﻿//////////////////////////////////////////////////////////////////////////////
//
//  Copyright © 1998-2024 Glodon Company Limited.  All rights reserved.
//
//  Use of this software is subject to the terms of the Glodon license
//  agreement provided at the time of installation or download, or which
//  otherwise accompanies this software in either electronic or hard copy form.  
//
//////////////////////////////////////////////////////////////////////////////

#pragma once
#include "GmFamilyService.h"
#include "IExternalObject.h"
#include "IFamilyParameterDefinition.h"

namespace gcmp
{
    class IParameter;
    class IFamilyType;
    class IParameterCustomData;
}

namespace gfam
{
    // \brief 族管理器
    class GM_FAMILY_SERVICE_EXPORT IFamilyManager : public gcmp::IExternalObject
    {
        DEFINE_CAST_DERIVED(gfam::IFamilyManager, gcmp::IExternalObject)

    public:
        /// \brief 创建一个族管理器
        /// 
        /// \return 返回创建的族管理器
        /// \note 每个文档只能创建一个族管理器
        static IFamilyManager* Create(gcmp::IDocument* pDoc);

        /// \brief 获取族管理器
        /// 
        /// \return 族管理器
        static IFamilyManager* Get(const gcmp::IDocument* pDoc);


        /// \brief 返回给定名字的族类型
        ///
        /// 一个族中不存在同名的族类型
        /// \param familyTypeName 族类型名字
        /// \return 如果存在，返回族类型对象，否则返回空指针
        virtual const gcmp::IFamilyType* GetFamilyTypeByName(const std::wstring& familyTypeName) const = 0;

        /// \brief 返回给定uid的族类型
        ///
        /// 一个族中不存在同名的族类型
        /// \param familyTypeUid 族类型uid
        /// \return 如果存在，返回族类型对象，否则返回空指针
        virtual const gcmp::IFamilyType* GetFamilyTypeByUid(const gcmp::UniIdentity& familyTypeUid) const = 0;

        ///// \brief 返回给定名字的族类型
        /////
        ///// 一个族中不存在同名的族类型
        ///// \param familyTypeName 族类型名字
        ///// \return 如果存在，返回族类型对象，否则返回空指针
        //virtual IFamilyType* GetFamilyTypeByName(const std::wstring& familyTypeName) = 0;

        /// \brief 返回所有族类型
        ///
        /// \return 族类型数组
        virtual std::vector<const gcmp::IFamilyType*> GetFamilyTypes() const = 0;

        /// \brief 添加族类型
        ///
        /// \param familyTypeName 类型名称
        /// \return 成功返回true，失败返回false
        virtual bool AddFamilyType(const std::wstring& familyTypeName) = 0;

        /// \brief 添加族类型
        ///
        /// \param familyTypeName 类型名称
        /// \param templateFamilyTypeName 模板类型名称
        /// \return 成功返回true，失败返回false
        virtual bool AddFamilyType(const std::wstring& familyTypeName, const std::wstring& templateFamilyTypeName) = 0;

        /// \brief 添加族类型
        ///
        /// \param familyTypeName 类型名称
        /// \param familyTypeUid  类型uid
        /// \param templateFamilyTypeName 模板类型名称
        /// \return 成功返回true，失败返回false
        virtual bool AddFamilyType(const std::wstring& familyTypeName, const gcmp::UniIdentity& familyTypeUid, const std::wstring& templateFamilyTypeName) = 0;

        /// \brief 删除族类型
        ///
        /// 如果删除的是最后一个族类型，则会新建一个默认的族类型
        /// \param IFamilyType 族类型
        /// \return 成功返回true，失败返回false
        virtual bool DeleteFamilyType(const std::wstring& familyTypeName) = 0;

        /// \brief 设置当前族类型
        /// 
        /// \param typeName 类型名称
        /// \return true 设置成功，false 设置失败
        virtual bool SetCurrentFamilyType(const std::wstring& typeName) = 0;
        
        /// \brief 获取当前族类型
        /// 
        /// \return 族类型名称
        virtual std::wstring GetCurrentFamilyTypeName() const = 0;

        /// \brief 获取当前族类型
        /// 
        /// \return 返回族类型对象指针
        virtual const gcmp::IFamilyType* GetCurrentFamilyType() const = 0;

        /// \brief 重命名当前族类型
        /// 
        /// \param newCurrentTypeName 新的名称
        /// \return true 设置成功，false 设置失败
        virtual bool RenameCurrentFamilyType(const std::wstring& newCurrentTypeName) = 0;

        /// \brief 重命名族类型
        /// 
        /// \param pFamilyType 目标族类型
        /// \param newCurrentTypeName 新的名称
        /// \return true 设置成功，false 设置失败
        virtual bool RenameFamilyType(const gcmp::IFamilyType* pFamilyType, const std::wstring& newTypeName) = 0;


        /// \brief 获取缩放比例
        /// 
        /// \return 缩放比例
        virtual double GetScale() const = 0;

        /// \brief 设置缩放比例
        /// 
        /// \param scaleValue 缩放比例
        /// \return 设置成功返回true,否则返回false
        virtual bool SetScale(double scaleValue) = 0;


        /////////////////////////////////////////////////////////////////////////////////////////////////


        ///// \brief 添加族类型
        ///// 
        ///// \param typeName 类型名称
        ///// \return true 添加成功，false 添加失败
        //virtual bool AddNewType(const std::wstring& typeName) = 0;

        ///// \brief 设置当前族类型
        ///// 
        ///// \param typeName 类型名称
        ///// \return true 设置成功，false 设置失败
        //virtual bool SetCurrentType(const std::wstring& typeName) = 0;

        ///// \brief 获取当前族类型
        ///// 
        ///// \return 族类型名称
        //virtual std::wstring GetCurrentTypeName() const = 0;

        ///// \brief 获取族类型是否存在
        ///// 
        ///// \return 族类型存在返回true,否则返回false
        //virtual bool IsTypeExist(const std::wstring& typeName) const = 0;

        ///// \brief 重命名当前族类型
        ///// 
        ///// \param newCurrentTypeName 新的名称
        ///// \return true 设置成功，false 设置失败
        ///// \note 修改当前族类型的名称时必需通过此接口（要同步MAP中的数据）
        //virtual bool RenameCurrentType(const std::wstring& newCurrentTypeName) = 0;

        ///// \brief 重命名族类型
        ///// 
        ///// \param oldTypeName 旧的族类型名称
        ///// \param newTypeName 新的族类型名称
        ///// \return true 设置成功，false 设置失败
        //virtual bool RenameType(const std::wstring& oldTypeName, const std::wstring& newTypeName) = 0;

        ///// \brief 移除族类型
        ///// 
        ///// \param typeName 族类型名称
        ///// \return true 操作成功，false 操作失败
        //virtual bool RemoveType(const std::wstring& typeName) = 0;

        ///// \brief 获取族类型描述信息
        ///// 
        ///// \param typeName 族类型名称
        ///// \return 族类型描述信息
        //virtual std::wstring GetTypeDescription(const std::wstring& typeName) = 0;
        //
        ///// \brief 获取所有族类型名称
        ///// 
        ///// \return 所有族类型名称
        //virtual std::vector<std::wstring> GetTypeNames() = 0;

         ////////////////////////////////////////////////////////////////////////////////////////////////////////
    public:

        /// \brief 添加族参数定义
        /// 
        /// \param pFamilyParameterDefinition 族参数定义
        /// \return true 添加成功，false 添加失败
        virtual bool AddFamilyParameterDefinition(IFamilyParameterDefinition* pFamilyParameterDefinition) = 0;

        /// \brief 在位置position前插入族参数定义
        /// 
        /// \param position 插入位置
        /// \param pFamilyParameterDefinition 族参数定义
        /// \return true 插入成功，false 插入失败
        virtual bool InsertFamilyParameterDefinition(size_t position, IFamilyParameterDefinition* pFamilyParameterDefinition) = 0;

        /// \brief 添加族参数定义
        /// 
        /// \param pFamilyParameterDefinition 族参数定义
        /// \param userVisible 参数是否可见
        /// \param userModifiable 参数是否可编辑
        /// \return true 添加成功，false 添加失败
        /// \note 如果已存在同名参数，将会失败
        virtual bool AddFamilyParameterDefinition(IFamilyParameterDefinition* pFamilyParameterDefinition, bool userVisible, bool userModifiable) = 0;


        /// \brief 添加族参数定义
        /// 
        /// \param name 参数名称
        /// \param familyParameterType 参数类型
        /// \param isInstance 是否实例参数
        /// \param formula 表达式
        /// \return 添加成功则返回对应的族参数定义指针
        virtual const IFamilyParameterDefinition* AddFamilyParameterDefinition(const std::wstring& name, FamilyParameterType familyParameterType, bool isInstance, const std::wstring& formula) = 0;

        /// \brief 移除族参数定义
        /// 
        /// \param id 族参数定义的Element id
        /// \return true 移除成功，false 移除失败
        virtual bool RemoveFamilyParameterDefinition(const gcmp::ElementId& id) = 0;

        /// \brief 移除族参数定义
        /// 
        /// \param pFamilyParameterDefinition 族参数定义指针
        /// \return true 移除成功，false 移除失败
        virtual bool RemoveFamilyParameterDefinition(const IFamilyParameterDefinition* pFamilyParameterDefinition) = 0;

        /// \brief 根据ElementId获取族参数定义
        /// 
        /// \param elementId 族参数定义的ElementId
        /// \return 族参数定义
        virtual const IFamilyParameterDefinition* GetFamilyParameterDefinition(const gcmp::ElementId& id) const = 0;

        /// \brief 根据int Id获取族参数定义
        /// 
        /// \param paramId 族参数定义在文档中的id
        /// \return 族参数定义
        virtual const IFamilyParameterDefinition* GetFamilyParameterDefinition(Int32 paramId) const = 0;

        /// \brief 根据uid获取族参数定义
        /// 
        /// \param uid 族参数定义的uid
        /// \return 族参数定义
        virtual const IFamilyParameterDefinition* GetFamilyParameterDefinition(const gcmp::UniIdentity& uid) const = 0;

        /// \brief 根据名称获取族参数定义
        /// 
        /// \param parameterName 族参数定义的名称
        /// \return 族参数定义
        virtual const IFamilyParameterDefinition* GetFamilyParameterDefinition(const std::wstring& parameterName) const = 0;

        /// \brief 根据BIM标准编码获取族参数定义
        /// 
        /// \param attributeCode BIM标准编码
        /// \return 族参数定义
        virtual const IFamilyParameterDefinition* GetFamilyParameterDefinitionByBIMCode(const std::wstring& attributeCode) const = 0;


        /// \brief 获取族管理器中所有的族参数定义
        /// 
        /// \return 族参数定义ElementId数组
        virtual const std::vector<gcmp::ElementId>& GetFamilyParameterDefinitionIds() const = 0;


        // 更新
        //virtual bool UpdateFamiyParameterDefinition(const IFamilyParameterDefinition* pFamilyParameterDefinition, bool isInstance, const std::wstring& formula) = 0;

        /// \brief 更新族参数定义里的公式
        /// 
        /// \param pFamilyParameterDefinition 族参数定义指针
        /// \param formula 设置的公式
        /// \return 更新成功返回true, 失败返回false
        virtual bool UpdateFamilyParameterDefinition(const IFamilyParameterDefinition* pFamilyParameterDefinition, const std::wstring& formula) = 0;

        /// \brief 更新族参数定义里的实例参数选项
        /// 
        /// \param pFamilyParameterDefinition 族参数定义指针
        /// \param isInstance 是否为实例参数
        /// \return 更新成功返回true, 失败返回false
        virtual bool UpdateFamilyParameterDefinition(const IFamilyParameterDefinition* pFamilyParameterDefinition, bool isInstance) = 0;

        /// \brief 更新族参数定义的描述
        /// 
        /// \param pFamilyParameterDefinition 族参数定义指针
        /// \param description 描述
        /// \return 更新成功返回true, 失败返回false
        virtual bool UpdateFamilyParameterDefinitionDescription(const IFamilyParameterDefinition *pFamilyParameterDefinition, const std::wstring &description) = 0;

        /// \brief 更新族参数定义的分组名
        /// 
        /// \param pFamilyParameterDefinition 族参数定义指针
        /// \param groupName 分组名
        /// \return 更新成功返回true, 失败返回false
        virtual bool UpdateFamilyParameterDefinitionGroupName(const IFamilyParameterDefinition *pFamilyParameterDefinition, const std::wstring &groupName) = 0;

        // 是否需要？ 删掉重建？
        //virtual bool UpdateFamilyParameterDefinition(const std::wstring& name, const std::wstring& newName) = 0;

        /// \brief 获取族参数在文档中的参数id
        /// 
        /// \param pFamilyParameterDefinition 族参数定义指针
        /// \return 参数id
        virtual Int32 GetFamilyParameterDefinitionId(const IFamilyParameterDefinition* pFamilyParameterDefinition) const = 0;
        
        /// \brief 获取族参数在文档中的参数id
        /// 
        /// \param id 族参数定义的Element Id
        /// \return 参数id
        virtual Int32 GetFamilyParameterDefinitionId(const gcmp::ElementId& id) const = 0;

        /// \brief 设置族参数是否为驱动参数
        /// 
        /// \param pFamilyParameterDefinition 族参数定义指针
        /// \param isDrive 是否为驱动参数
        /// \return 设置成功返回true, 失败返回false
        virtual bool SetFamilyParameterAsDrive(const IFamilyParameterDefinition* pFamilyParameterDefinition, bool isDrive) = 0;

        /// \brief 设置族参数是否为几何参数
        /// 
        /// \param pFamilyParameterDefinition 族参数定义指针
        /// \param isGeomeric 是否为几何参数
        /// \return 设置成功返回true, 失败返回false
        virtual bool SetFamilyParameterAsGeometric(const IFamilyParameterDefinition* pFamilyParameterDefinition, bool isGeomeric) = 0;

        /// \brief 设置族参数的参数处理类型
        /// 
        /// \param pFamilyParameterDefinition 族参数定义指针
        /// \param parameterProcessType 参数处理类型
        /// \return 设置成功返回true, 失败返回false
        virtual bool SetFamilyParameterProcessType(const IFamilyParameterDefinition* pFamilyParameterDefinition, gcmp::ParameterProcessType parameterProcessType) = 0;


        /// \brief 设置当前族类型参数值
        /// 
        /// \param pFamilyParameterDefinition 族参数定义指针
        /// \param valueStorage 参数值
        /// \return 设置成功返回true, 失败返回false
        virtual bool SetParameterValueStorage(const IFamilyParameterDefinition* pFamilyParameterDefinition, gcmp::OwnerPtr<gcmp::IParameterValueStorage> valueStorage) = 0;
        
        /// \brief 设置当前族类型参数值
        /// 
        /// \param pFamilyParameterDefinition 族参数定义指针
        /// \param value 参数值
        /// \return 设置成功返回true, 失败返回false
        virtual bool SetParameterValueAsDouble(const IFamilyParameterDefinition* pFamilyParameterDefinition, double value) = 0;

        /// \brief 设置当前族类型参数值
        /// 
        /// \param pFamilyParameterDefinition 族参数定义指针
        /// \param value 参数值
        /// \return 设置成功返回true, 失败返回false
        virtual bool SetParameterValueAsElementId(const IFamilyParameterDefinition* pFamilyParameterDefinition, const gcmp::ElementId& value) = 0;

        /// \brief 设置当前族类型参数值
        /// 
        /// \param pFamilyParameterDefinition 族参数定义指针
        /// \param value 参数值
        /// \return 设置成功返回true, 失败返回false
        virtual bool SetParameterValueAsInteger(const IFamilyParameterDefinition* pFamilyParameterDefinition, int value) = 0;

        /// \brief 设置当前族类型参数值
        /// 
        /// \param pFamilyParameterDefinition 族参数定义指针
        /// \param value 参数值
        /// \return 设置成功返回true, 失败返回false
        virtual bool SetParameterValueAsString(const IFamilyParameterDefinition* pFamilyParameterDefinition, const std::wstring& value) = 0;

        /// \brief 设置当前族类型参数值
        /// 
        /// \param pFamilyParameterDefinition 族参数定义指针
        /// \param value 参数值
        /// \return 设置成功返回true, 失败返回false
        virtual bool SetParameterValueAsBool(const IFamilyParameterDefinition* pFamilyParameterDefinition, bool value) = 0;

        /// \brief 设置当前族类型参数值
        /// 
        /// \param pFamilyParameterDefinition 族参数定义指针
        /// \param value 参数值
        /// \return 设置成功返回true, 失败返回false
        virtual bool SetParameterValueAsCustomData(const IFamilyParameterDefinition* pFamilyParameterDefinition, gcmp::OwnerPtr<gcmp::IParameterCustomData> value) = 0;


        /// \brief 设置参数值
        /// 
        /// \param typeName 族类型名称
        /// \param pFamilyParameterDefinition 族参数定义指针
        /// \param value 参数值
        /// \return 设置成功返回true, 失败返回false
        virtual bool SetParameterValueAsDouble(const std::wstring& typeName, const IFamilyParameterDefinition* pFamilyParameterDefinition, double value) = 0;
        /// \brief 设置参数值
        /// 
        /// \param typeName 族类型名称
        /// \param pFamilyParameterDefinition 族参数定义指针
        /// \param value 参数值
        /// \return 设置成功返回true, 失败返回false
        virtual bool SetParameterValueAsElementId(const std::wstring& typeName, const IFamilyParameterDefinition* pFamilyParameterDefinition, const gcmp::ElementId& value) = 0;
        /// \brief 设置参数值
        /// 
        /// \param typeName 族类型名称
        /// \param pFamilyParameterDefinition 族参数定义指针
        /// \param value 参数值
        /// \return 设置成功返回true, 失败返回false
        virtual bool SetParameterValueAsInteger(const std::wstring& typeName, const IFamilyParameterDefinition* pFamilyParameterDefinition, int value) = 0;
        /// \brief 设置参数值
        /// 
        /// \param typeName 族类型名称
        /// \param pFamilyParameterDefinition 族参数定义指针
        /// \param value 参数值
        /// \return 设置成功返回true, 失败返回false
        virtual bool SetParameterValueAsString(const std::wstring& typeName, const IFamilyParameterDefinition* pFamilyParameterDefinition, const std::wstring& value) = 0;
        /// \brief 设置参数值
        /// 
        /// \param typeName 族类型名称
        /// \param pFamilyParameterDefinition 族参数定义指针
        /// \param value 参数值
        /// \return 设置成功返回true, 失败返回false
        virtual bool SetParameterValueAsBool(const std::wstring& typeName, const IFamilyParameterDefinition* pFamilyParameterDefinition, bool value) = 0;
        /// \brief 设置参数值
        /// 
        /// \param typeName 族类型名称
        /// \param pFamilyParameterDefinition 族参数定义指针
        /// \param valueStorage 参数值
        /// \return 设置成功返回true, 失败返回false
        virtual bool SetParameterValueStorage(const std::wstring& typeName, const IFamilyParameterDefinition* pFamilyParameterDefinition, gcmp::OwnerPtr<gcmp::IParameterValueStorage> valueStorage) = 0;


        /// \brief 设置当前族类型参数值
        /// 
        /// \param typeName 族类型名称
        /// \param pFamilyParameterDefinition 族参数定义指针
        /// \param value 参数值
        /// \return 设置成功返回true, 失败返回false
        virtual bool SetParameterValueAsCustomData(const std::wstring& typeName, const IFamilyParameterDefinition* pFamilyParameterDefinition, gcmp::OwnerPtr<gcmp::IParameterCustomData> value) = 0;


        /// \brief 获取当前族类型的参数值
        /// 
        /// \param pFamilyParameterDefinition 族参数定义指针
        /// \return double型参数值
        virtual double GetParameterValueAsDouble(const IFamilyParameterDefinition* pFamilyParameterDefinition) const = 0;
        /// \brief 获取当前族类型的参数值
        /// 
        /// \param pFamilyParameterDefinition 族参数定义指针
        /// \return int型参数值
        virtual int GetParameterValueAsInteger(const IFamilyParameterDefinition* pFamilyParameterDefinition) const = 0;
        /// \brief 获取当前族类型的参数值
        /// 
        /// \param pFamilyParameterDefinition 族参数定义指针
        /// \return wstring型参数值
        virtual std::wstring GetParameterValueAsString(const IFamilyParameterDefinition* pFamilyParameterDefinition) const = 0;
        /// \brief 获取当前族类型的参数值
        /// 
        /// \param pFamilyParameterDefinition 族参数定义指针
        /// \return 布尔型参数值
        virtual bool GetParameterValueAsBool(const IFamilyParameterDefinition* pFamilyParameterDefinition) const = 0;
        /// \brief 获取当前族类型的参数值
        /// 
        /// \param pFamilyParameterDefinition 族参数定义指针
        /// \return ElementId型参数值
        virtual gcmp::ElementId GetParameterValueAsElementId(const IFamilyParameterDefinition* pFamilyParameterDefinition) const = 0;


        /// \brief 获取当前族类型的参数值
        /// 
        /// \param pFamilyParameterDefinition 族参数定义指针
        /// \return IParameterCustomData型参数指针
        virtual const gcmp::IParameterCustomData* GetParameterValueAsCustomData(const IFamilyParameterDefinition* pFamilyParameterDefinition) const = 0;

        /// \brief 获取参数值
        /// 
        /// \param typeName 族类型名称
        /// \param pFamilyParameterDefinition 族参数定义指针
        /// \return double型参数值
        virtual double GetParameterValueAsDouble(const std::wstring& typeName, const IFamilyParameterDefinition* pFamilyParameterDefinition) const = 0;

        /// \brief 获取参数值
        /// 
        /// \param typeName 族类型名称
        /// \param pFamilyParameterDefinition 族参数定义指针
        /// \return int型参数值
        virtual int GetParameterValueAsInteger(const std::wstring& typeName, const IFamilyParameterDefinition* pFamilyParameterDefinition) const = 0;
        
        /// \brief 获取参数值
        /// 
        /// \param typeName 族类型名称
        /// \param pFamilyParameterDefinition 族参数定义指针
        /// \return wstring型参数值
        virtual std::wstring GetParameterValueAsString(const std::wstring& typeName, const IFamilyParameterDefinition* pFamilyParameterDefinition) const = 0;

        /// \brief 获取参数值
        /// 
        /// \param typeName 族类型名称
        /// \param pFamilyParameterDefinition 族参数定义指针
        /// \return 布尔型参数值
        virtual bool GetParameterValueAsBool(const std::wstring& typeName, const IFamilyParameterDefinition* pFamilyParameterDefinition) const = 0;

        /// \brief 获取参数值
        /// 
        /// \param typeName 族类型名称
        /// \param pFamilyParameterDefinition 族参数定义指针
        /// \return ElementId参数值
        virtual gcmp::ElementId GetParameterValueAsElementId(const std::wstring& typeName, const IFamilyParameterDefinition* pFamilyParameterDefinition) const = 0;

        /// \brief 获取参数值
        /// 
        /// \param typeName 族类型名称
        /// \param pFamilyParameterDefinition 族参数定义指针
        /// \return IParameterCustomData型参数指针
        virtual const gcmp::IParameterCustomData* GetParameterValueAsCustomData(const std::wstring& typeName, const IFamilyParameterDefinition* pFamilyParameterDefinition) const = 0;


        /// \brief 设置参数值
        /// 
        /// \param typeName 族类型名称
        /// \param parameter 参数
        /// \return 设置成功返回true, 失败返回false
        virtual bool SetParameter(const std::wstring& typeName, gcmp::OwnerPtr<gcmp::IParameter> parameter) = 0;

        /// \brief 设置当前族类型的参数值
        /// 
        /// \param parameter 参数
        /// \return 设置成功返回true, 失败返回false
        virtual bool SetParameter(gcmp::OwnerPtr<gcmp::IParameter> parameter) = 0;

        /// \brief 根据族参数定义获取参数
        /// 
        /// \param uid 族参数定义指针
        /// \param 当前族类型下对应的参数
        virtual const gcmp::IParameter* GetParameter(const IFamilyParameterDefinition* pFamilyParameterDefinition) const = 0;

        /// \brief 根据uid获取参数
        /// 
        /// \param uid 族参数定义的uid
        /// \return 当前族类型下对应的参数
        virtual const gcmp::IParameter* GetParameter(const gcmp::UniIdentity& uid) const = 0;

        /// \brief 根据文档中Id获取参数
        /// 
        /// \param paramId 族参数定义在文档中的id
        /// \return 当前族类型下对应的参数
        virtual const gcmp::IParameter*  GetParameter(int paramId) const = 0;

        /// \brief 获取参数
        /// 
        /// \param 族参数名称
        /// \return 当前族类型下对应的参数
        virtual const gcmp::IParameter* GetParameter(const std::wstring& parameterName) const = 0;


        /// \brief 获取参数
        /// 
        /// \param famTypeName 族类型名称
        /// \param pFamilyParameterDefinition 族参数定义
        /// \return 族类型下对应的参数
        virtual const gcmp::IParameter* GetParameter(const std::wstring& typeName, const IFamilyParameterDefinition* pFamilyParameterDefinition) const = 0;


        /// \brief 获取当前族类型名称关联更新id
        /// 
        /// \return 关联更新id
        virtual RegenDataId GetCurrentFamilyTypeNameRdId() const = 0;

    public:
        /// \brief 获得元素所属文档
        /// \return IDocument* 文档指针
        virtual gcmp::IDocument* GetDocument() const = 0;

        /// \brief 获得元素的Id
        /// \return ElementId 元素的Id
        virtual gcmp::ElementId GetElementId() const = 0;

        /// \brief 获得元素基础信息模块
        /// \return IBasicInformation* 基础信息模块指针
        virtual gcmp::IElementBasicInformation* GetBasicInformation() = 0;

        /// \brief 获得元素基础信息模块
        /// \return IBasicInformation* 基础信息模块指针
        virtual const gcmp::IElementBasicInformation* GetBasicInformation()const = 0;

        /// \brief 设置元素所属类别的Uid
        /// \param uid 类别Uid
        /// \return bool 设置成功返回true，否则返回false。
        virtual bool SetCategoryUid(const gcmp::UniIdentity& value) = 0;

        /// \brief 设置元素所属类别的Uid
        /// \param uid 类别Uid
        /// \return bool 设置成功返回true，否则返回false。
        virtual const gcmp::UniIdentity& GetCategoryUid() const = 0;

        /// \brief 获得参数行为接口
        /// \return const IElementParameters* 参数行为接口
        virtual const gcmp::IElementParameters* GetElementParameters() const = 0;

        /// \brief 获得参数行为接口
        /// \return const IElementParameters* 参数行为接口
        virtual gcmp::IElementParameters* GetElementParameters()  = 0;

        // 获取轮廓
        virtual gcmp::ElementId GetBuiltInProfileInstanceType() const = 0;

        /// \brief 更新所有表达式参数
        /// \param errorMessage 输出的错误信息
        /// \return bool 设置成功返回true，否则返回false。
        virtual bool UpdateAllExpressions(std::wstring& errorMessage) = 0;

        /// \brief 更新一个表达式参数
        /// \param [in] pParameterDefinition 族参数定义指针
        /// \return bool 更新成功返回true，否则返回false。
        virtual bool UpdateParameterExpression(const gfam::IFamilyParameterDefinition *pParameterDefinition) = 0;
    };

} // end namespace gfam
